﻿package mortal.game.view.forging.util
{
    import Message.DB.Tables.*;
    import Message.Game.*;
    import Message.Public.*;
    import extend.language.*;
    import flash.utils.*;
    import mortal.game.cache.*;
    import mortal.game.mvc.*;
    import mortal.game.resource.*;
    import mortal.game.resource.info.item.*;
    import mortal.game.resource.tableConfig.*;
    import mortal.game.view.best.*;
    import mortal.game.view.common.util.*;
    import mortal.game.view.forging.*;
    import mortal.game.view.forging.data.*;
    import mortal.game.view.palyer.*;

    public class GemUtil extends Object
    {
        private static var _gemDic:Dictionary = new Dictionary();
        private static var _baseGemDic:Dictionary = new Dictionary();
        public static var currOperType:int;
        public static var isNeedUpdate:Boolean;

        public function GemUtil()
        {
            return;
        }// end function

        public static function getPackAvailableGems(param1:ItemData) : Array
        {
            var _loc_2:* = EquipJewelMatchConfig.instance.getJewelTypeByEquipType(param1.itemInfo.type);
            var _loc_3:* = Cache.instance.pack.backPackCache.getGemByType(_loc_2);
            return _loc_3;
        }// end function

        public static function getBetterGems(param1:ItemData, param2:ItemData) : Array
        {
            var _loc_5:ItemData = null;
            var _loc_3:* = getPackAvailableGems(param1);
            var _loc_4:int = 0;
            while (_loc_4 < _loc_3.length)
            {
                
                _loc_5 = _loc_3[_loc_4] as ItemData;
                if (_loc_5.itemInfo.color <= param2.itemInfo.color)
                {
                    _loc_3.splice(_loc_4, 1);
                    _loc_4 = _loc_4 - 1;
                }
                _loc_4++;
            }
            return _loc_3;
        }// end function

        public static function getOneTypeGem(param1:Array) : ItemData
        {
            var _loc_2:int = 0;
            var _loc_3:ItemData = null;
            if (param1.length > 0)
            {
                _loc_2 = param1[0].itemInfo.color;
                for each (_loc_3 in param1)
                {
                    
                    if (_loc_2 != _loc_3.itemInfo.color)
                    {
                        return null;
                    }
                }
                return param1[0] as ItemData;
            }
            return null;
        }// end function

        public static function getLowestColorGem(param1:int) : ItemData
        {
            var _loc_2:ItemData = null;
            var _loc_3:int = 0;
            var _loc_4:ItemInfo = null;
            if (_gemDic[param1] == null)
            {
                _loc_3 = EquipJewelMatchConfig.instance.getJewelTypeByEquipType(param1);
                _loc_4 = ItemConfig.instance.getItemInfoByCondition(EGroup._EGroupStuff, EStuff._EStuffJewel, _loc_3, 1, 2);
                if (_loc_4)
                {
                    _gemDic[param1] = _loc_4.code;
                    _loc_2 = new ItemData(_loc_4.code);
                }
            }
            else
            {
                _loc_2 = new ItemData(_gemDic[param1] as int);
            }
            return _loc_2;
        }// end function

        public static function getCanEmbedGemHole() : SJewelHoleInfo
        {
            var _loc_3:SJewelHoleInfo = null;
            var _loc_1:* = GameController.forging.forgingWin.equipDisplaySpr.currSelEquip;
            var _loc_2:* = Cache.instance.forging.getGemDataByEquipType(_loc_1.itemData.itemInfo.type);
            for each (_loc_3 in _loc_2)
            {
                
                if (_loc_3.itemCode == 0)
                {
                    return _loc_3;
                }
            }
            return null;
        }// end function

        public static function getCanReplaceGemHole(param1:ItemData) : SJewelHoleInfo
        {
            var _loc_4:SJewelHoleInfo = null;
            var _loc_6:SJewelHoleInfo = null;
            var _loc_7:ItemData = null;
            var _loc_8:Object = null;
            var _loc_2:* = GameController.forging.forgingWin.equipDisplaySpr.currSelEquip;
            var _loc_3:* = Cache.instance.forging.getGemDataByEquipType(_loc_2.itemData.itemInfo.type);
            var _loc_5:Array = [];
            for each (_loc_6 in _loc_3)
            {
                
                if (_loc_6.itemCode != 0)
                {
                    _loc_7 = new ItemData(_loc_6.itemCode);
                    _loc_8 = {};
                    _loc_8.itemData = _loc_7;
                    _loc_8.holeInfo = _loc_6;
                    _loc_5.push(_loc_8);
                }
            }
            if (_loc_5.length > 0)
            {
                _loc_5.sort(sortByColorAndStrengLevel);
                if (param1.itemInfo.color > _loc_5[0].itemData.itemInfo.color)
                {
                    return _loc_5[0].holeInfo as SJewelHoleInfo;
                }
            }
            return null;
        }// end function

        private static function sortByColorAndStrengLevel(param1:Object, param2:Object) : int
        {
            if (param1.itemData.itemInfo.color < param2.itemData.itemInfo.color)
            {
                return -1;
            }
            if (param1.itemData.itemInfo.color > param2.itemData.itemInfo.color)
            {
                return 1;
            }
            return sortByStrengLevel(param1, param2);
        }// end function

        private static function sortByStrengLevel(param1:Object, param2:Object) : int
        {
            if (param1.holeInfo.strengthLevel > param2.holeInfo.strengthLevel)
            {
                return -1;
            }
            if (param1.holeInfo.strengthLevel < param2.holeInfo.strengthLevel)
            {
                return 1;
            }
            return 0;
        }// end function

        public static function getGemOpenLevel(param1:int) : int
        {
            var _loc_3:Array = null;
            var _loc_2:* = ConstConfig.instance.getObjectByName("TConstJewelHoleOpenLevel").constValueStr;
            if (_loc_2)
            {
                _loc_3 = _loc_2.split("#");
                if (_loc_3)
                {
                    return int(_loc_3[(param1 - 1)]);
                }
            }
            return 999;
        }// end function

        public static function isGemCanReplace(param1:ItemData, param2:ItemData) : Boolean
        {
            var _loc_3:* = GemUtil.getBetterGems(param1, param2);
            if (_loc_3.length != 0)
            {
                return true;
            }
            return false;
        }// end function

        public static function getCanEmbedHoleInEquip(param1:ItemData) : EquipRecommendGemData
        {
            var _loc_2:EquipRecommendGemData = null;
            var _loc_4:SJewelHoleInfo = null;
            var _loc_5:ItemData = null;
            var _loc_6:TEquipJewelMatch = null;
            var _loc_3:* = Cache.instance.forging.getGemDataByEquipType(param1.itemInfo.type);
            for each (_loc_4 in _loc_3)
            {
                
                if (_loc_4.itemCode == 0)
                {
                    _loc_5 = EquipmentUtil.hasMatchGemInBackPack(param1);
                    if (_loc_5)
                    {
                        _loc_2 = new EquipRecommendGemData();
                        _loc_6 = EquipJewelMatchConfig.instance.getInfoByType(param1.itemInfo.type);
                        _loc_2.equipData = param1;
                        _loc_2.gemType = _loc_6.jeweltype;
                        _loc_2.gemName = _loc_6.desc + Language.getString(41055);
                        _loc_2.recommendType = BestConst.RecommendType_GemEmbed;
                    }
                }
            }
            return _loc_2;
        }// end function

        public static function getCanAdvanceHoleInEquip(param1:ItemData) : EquipRecommendGemData
        {
            var _loc_2:EquipRecommendGemData = null;
            var _loc_4:SJewelHoleInfo = null;
            var _loc_5:ItemData = null;
            var _loc_3:* = Cache.instance.forging.getGemDataByEquipType(param1.itemInfo.type);
            for each (_loc_4 in _loc_3)
            {
                
                if (_loc_4.itemCode != 0)
                {
                    _loc_5 = new ItemData(_loc_4.itemCode);
                    if (isGemCanAdvance(_loc_5))
                    {
                        _loc_2 = new EquipRecommendGemData();
                        _loc_2.equipData = param1;
                        _loc_2.gemName = _loc_5.itemInfo.name;
                        _loc_2.gemData = _loc_5;
                        _loc_2.gemHoleIndex = _loc_4.index;
                        _loc_2.recommendType = BestConst.RecommendType_GemAdvance;
                    }
                }
            }
            return _loc_2;
        }// end function

        public static function getCanStrengHoleInEquip(param1:ItemData) : EquipRecommendGemData
        {
            var _loc_2:EquipRecommendGemData = null;
            var _loc_4:SJewelHoleInfo = null;
            var _loc_5:ItemData = null;
            var _loc_3:* = Cache.instance.forging.getGemDataByEquipType(param1.itemInfo.type);
            for each (_loc_4 in _loc_3)
            {
                
                if (_loc_4.itemCode != 0)
                {
                    _loc_5 = new ItemData(_loc_4.itemCode);
                    if (isGemCanStreng(_loc_5, (_loc_4.strengthLevel + 1)))
                    {
                        _loc_2 = new EquipRecommendGemData();
                        _loc_2.equipData = param1;
                        _loc_2.gemName = _loc_5.itemInfo.name;
                        _loc_2.gemData = _loc_5;
                        _loc_2.gemHoleIndex = _loc_4.index;
                        _loc_2.recommendType = BestConst.RecommendType_GemStreng;
                    }
                }
            }
            return _loc_2;
        }// end function

        public static function getCanStrengHoleInEquip2(param1:ItemData) : EquipRecommendGemData
        {
            var _loc_2:EquipRecommendGemData = null;
            var _loc_4:SJewelHoleInfo = null;
            var _loc_5:ItemData = null;
            var _loc_3:* = Cache.instance.forging.getGemDataByEquipType(param1.itemInfo.type);
            for each (_loc_4 in _loc_3)
            {
                
                if (_loc_4.itemCode != 0)
                {
                    _loc_5 = new ItemData(_loc_4.itemCode);
                    if (isGemCanStreng(_loc_5, (_loc_4.strengthLevel + 1)))
                    {
                        _loc_2 = new EquipRecommendGemData();
                        _loc_2.equipData = param1;
                        _loc_2.gemName = _loc_5.itemInfo.name;
                        _loc_2.gemData = _loc_5;
                        _loc_2.gemHoleIndex = _loc_4.index;
                        _loc_2.recommendType = BestConst.RecommendType_GemStreng;
                    }
                }
            }
            return _loc_2;
        }// end function

        public static function getRecommandGemInfo() : EquipRecommendGemData
        {
            var _loc_4:EquipRecommendGemData = null;
            var _loc_5:EquipRecommendGemData = null;
            var _loc_6:EquipRecommendGemData = null;
            var _loc_8:ItemData = null;
            var _loc_9:EquipRecommendGemData = null;
            var _loc_10:EquipRecommendGemData = null;
            var _loc_11:EquipRecommendGemData = null;
            var _loc_1:Boolean = false;
            var _loc_2:Boolean = false;
            var _loc_3:Boolean = false;
            var _loc_7:* = Cache.instance.pack.packRolePackCache.getAllRoleEquips();
            for each (_loc_8 in _loc_7)
            {
                
                if (!_loc_1)
                {
                    _loc_9 = getCanEmbedHoleInEquip(_loc_8);
                    if (_loc_9 != null)
                    {
                        _loc_1 = true;
                        _loc_4 = _loc_9;
                    }
                }
                if (!_loc_1 && !_loc_2)
                {
                    _loc_10 = getCanAdvanceHoleInEquip(_loc_8);
                    if (_loc_10 != null)
                    {
                        _loc_2 = true;
                        _loc_5 = _loc_10;
                    }
                }
                if (!_loc_1 && !_loc_2 && !_loc_3)
                {
                    _loc_11 = getCanStrengHoleInEquip2(_loc_8);
                    if (_loc_11 != null)
                    {
                        _loc_3 = true;
                        _loc_6 = _loc_11;
                    }
                }
            }
            if (_loc_1)
            {
                return _loc_4;
            }
            if (_loc_2)
            {
                return _loc_5;
            }
            if (_loc_3)
            {
                return _loc_6;
            }
            return null;
        }// end function

        public static function getGemInfoData(param1:SJewelHoleInfo, param2:ItemData = null) : GemInfoData
        {
            var _loc_4:PlayerEquipItem = null;
            var _loc_5:ItemData = null;
            var _loc_6:Array = null;
            var _loc_7:TEquipJewelMatch = null;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:ItemData = null;
            var _loc_11:String = null;
            var _loc_12:int = 0;
            var _loc_13:int = 0;
            var _loc_14:Boolean = false;
            var _loc_15:Boolean = false;
            var _loc_3:* = new GemInfoData();
            if (param1)
            {
                _loc_3.strengLevel = param1.strengthLevel;
                if (param1.itemCode == 0)
                {
                    _loc_4 = (GameController.forging.view as ForgingModule).equipDisplaySpr.currSelEquip;
                    _loc_5 = param2 == null ? (_loc_4.itemData) : (param2);
                    _loc_6 = getPackAvailableGems(_loc_5);
                    if (_loc_6.length != 0)
                    {
                        _loc_3.operType = GemOperType.OperType_CanEmbed;
                    }
                    else
                    {
                        _loc_3.operType = GemOperType.OperType_CanBuy;
                        _loc_7 = EquipJewelMatchConfig.instance.getInfoByType(_loc_5.itemInfo.type);
                        if (_loc_7)
                        {
                            _loc_8 = _loc_7.jeweltype;
                            _loc_9 = GemUtil.getBaseGemCode(_loc_8);
                            _loc_3.gemData = new ItemData(_loc_9);
                        }
                    }
                }
                else
                {
                    _loc_10 = new ItemData(param1.itemCode);
                    _loc_3.gemData = _loc_10;
                    _loc_11 = GameDefConfig.instance.getItem("FightRoleAttribute", _loc_10.itemInfo.type).text;
                    _loc_11 = _loc_11 == "maxLife" ? ("life") : (_loc_11);
                    _loc_12 = _loc_10.itemInfo.color;
                    _loc_13 = JewelUpdateConfig.instance.getGemAttr(_loc_12, param1.strengthLevel, _loc_11);
                    _loc_10.extInfo = new ItemExInfo();
                    _loc_10.extInfo.strengthen = param1.strengthLevel;
                    _loc_10.extInfo.currentStrengthen = _loc_13;
                    if (isGemCanStreng(_loc_10, (param1.strengthLevel + 1)))
                    {
                        _loc_14 = true;
                    }
                    if (isGemCanAdvance(_loc_10))
                    {
                        _loc_15 = true;
                    }
                    if (_loc_14 && _loc_15)
                    {
                        _loc_3.operType = GemOperType.OperType_CanUpgradeAndAdvance;
                    }
                    else if (_loc_14)
                    {
                        _loc_3.operType = GemOperType.OperType_CanUpgrade;
                    }
                    else if (_loc_15)
                    {
                        _loc_3.operType = GemOperType.OperType_CanAdvance;
                    }
                }
            }
            return _loc_3;
        }// end function

        public static function isGemCanStreng(param1:ItemData, param2:int) : Boolean
        {
            var _loc_3:TJewelUpdate = null;
            var _loc_4:int = 0;
            var _loc_5:int = 0;
            if (param1 && param1.itemInfo)
            {
                _loc_3 = JewelUpdateConfig.instance.getInfoByColorAndLevel(param1.itemInfo.color, param2);
                if (_loc_3)
                {
                    _loc_4 = _loc_3.exp;
                    _loc_5 = Cache.instance.pack.backPackCache.getItemCountByItemCode(getBaseGemCode(param1.itemInfo.type));
                    if (_loc_5 >= _loc_4)
                    {
                        return true;
                    }
                }
            }
            return false;
        }// end function

        public static function isGemCanAdvance(param1:ItemData) : Boolean
        {
            var _loc_2:Array = null;
            var _loc_3:ItemData = null;
            if (param1 && param1.itemInfo)
            {
                _loc_2 = Cache.instance.pack.backPackCache.getItemsByGroupCategoryAndType(param1.itemInfo.group, EStuff._EPropJewelScroll, param1.itemInfo.type);
                if (param1.itemInfo.color < ForgingConst.GemColorMaxLevel)
                {
                    for each (_loc_3 in _loc_2)
                    {
                        
                        if (_loc_3.itemInfo.color > param1.itemInfo.color)
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }// end function

        public static function getBaseGemCode(param1:int) : int
        {
            var _loc_2:Array = null;
            var _loc_3:ItemInfo = null;
            if (!_baseGemDic[param1])
            {
                _loc_2 = ItemConfig.instance.getItemByCategoryAndtype(EStuff._EStuffJewel, param1);
                for each (_loc_3 in _loc_2)
                {
                    
                    if (_loc_3.color == 2 && _loc_3.itemLevel == 1)
                    {
                        _baseGemDic[param1] = _loc_3.code;
                        break;
                    }
                }
            }
            return _baseGemDic[param1] as int;
        }// end function

        public static function getDefaultEquip() : ItemData
        {
            var _loc_1:ItemData = null;
            var _loc_2:ItemData = null;
            var _loc_4:ItemData = null;
            var _loc_5:EquipGemOperState = null;
            var _loc_6:ItemData = null;
            var _loc_3:* = Cache.instance.pack.packRolePackCache.allItems;
            for each (_loc_4 in _loc_3)
            {
                
                if (_loc_4)
                {
                    _loc_5 = getEquipGemOperState(_loc_4);
                    if (_loc_5.isCanEmbed && !_loc_1)
                    {
                        _loc_1 = _loc_4;
                    }
                    if (_loc_5.isCanStreng && !_loc_2)
                    {
                        _loc_2 = _loc_4;
                    }
                }
            }
            if (_loc_1)
            {
                return _loc_1;
            }
            if (_loc_2)
            {
                return _loc_2;
            }
            _loc_6 = Cache.instance.pack.packRolePackCache.getItemDataByType(EEquip._EEquipWeapon);
            return _loc_6;
        }// end function

        public static function getEquipGemOperState(param1:ItemData) : EquipGemOperState
        {
            var _loc_4:SJewelHoleInfo = null;
            var _loc_5:GemInfoData = null;
            var _loc_2:* = new EquipGemOperState();
            var _loc_3:* = Cache.instance.forging.getGemDataByEquipType(param1.itemInfo.type);
            for each (_loc_4 in _loc_3)
            {
                
                _loc_5 = getGemInfoData(_loc_4, param1);
                switch(_loc_5.operType)
                {
                    case GemOperType.OperType_CanEmbed:
                    {
                        _loc_2.isCanEmbed = true;
                        break;
                    }
                    case GemOperType.OperType_CanUpgrade:
                    {
                        _loc_2.isCanStreng = true;
                        break;
                    }
                    case GemOperType.OperType_CanAdvance:
                    {
                        _loc_2.isCanAdvance = true;
                        break;
                    }
                    case GemOperType.OperType_CanUpgradeAndAdvance:
                    {
                        _loc_2.isCanStreng = true;
                        _loc_2.isCanAdvance = true;
                        break;
                    }
                    default:
                    {
                        break;
                    }
                }
            }
            return _loc_2;
        }// end function

    }
}
